/*
 * funcionesAlgoritmosPlanificacion.c
 *
 *  Created on: 29/11/2011
 *      Author: utn_so
 */
#include "funcionesAlgoritmosPlanificacion.h"
int32_t algoritmoScanLectura_ejecutar(struct estructuraLeer **punteroLectura, int32_t **sincroActivo, int32_t **traceActivo,int32_t **descriptor){

	int32_t siguienteALeer;
	int32_t diferenciaEntreSectores = 999999999;
	struct estructuraLeer *auxiliar;
	struct estructuraLeer *auxiliar2;
//	int *traceActivo;

	auxiliar = *punteroLectura;
	int32_t cambioDeSentido = 0;
	auxiliar2 = *punteroLectura;

		while(auxiliar2){
			if(auxiliar2->numeroSector / stConfig.iSectoresPista == posicionCabezal / stConfig.iSectoresPista){
				siguienteALeer = auxiliar2->numeroSector;

				if(traceTotal>0){
					if(auxiliar2->traceONoTrace == 1){
						*traceActivo = 1;
						traceTotal--;
					}else{
						*traceActivo = 0;
					}
					realizarTrace(siguienteALeer,cambioDeSentido);
				}else{
					if(siguienteALeer % stConfig.iSectoresPista == stConfig.iSectoresPista - 1)
						posicionCabezal = siguienteALeer - stConfig.iSectoresPista + 1;
					else {
						posicionCabezal = siguienteALeer;
						posicionCabezal++;
					}
				}

				if(auxiliar2->sincro == 1){
					*sincroActivo = 1;
				}else{
					*sincroActivo = 0;
				}
				*descriptor=(*punteroLectura)->descriptorAEnviar;
				buscarEliminarNodoLectura(&(*punteroLectura),siguienteALeer);
				return siguienteALeer;
			}
			pthread_mutex_lock(&mutexSincro);
			auxiliar2=auxiliar2->siguiente;
			pthread_mutex_unlock(&mutexSincro);
		}

	if(direccionSCAN)
	{
		while(auxiliar)
		{
			if((posicionCabezal <= auxiliar->numeroSector) && (auxiliar->numeroSector - stConfig.iCantidadPistas < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = auxiliar->numeroSector-stConfig.iCantidadPistas;
				siguienteALeer = auxiliar->numeroSector;

				if(auxiliar->traceONoTrace == 1){
					*traceActivo = 1;
				}else{
					*traceActivo = 0;
				}
				if(auxiliar->sincro == 1){
					*sincroActivo = 1;
				}else{
					*sincroActivo = 0;
				}

			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = *punteroLectura;
			direccionSCAN = 0;
			cambioDeSentido = 1;
			siguienteALeer = auxiliar->numeroSector;

			if(auxiliar->traceONoTrace == 1){
				*traceActivo = 1;
			}else{
				*traceActivo = 0;
			}
			if(auxiliar->sincro == 1){
				*sincroActivo = 1;
			}else{
				*sincroActivo = 0;
			}

			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector > siguienteALeer){
					siguienteALeer = auxiliar->numeroSector;
					if(auxiliar->traceONoTrace == 1){
						*traceActivo = 1;
					}else{
						*traceActivo = 0;
					}
					if(auxiliar->sincro == 1){
						*sincroActivo = 1;
					}else{
						*sincroActivo = 0;
					}
				}
				auxiliar = auxiliar->siguiente;
			}
		}
	}
	else
	{
		while(auxiliar)
		{
			if((posicionCabezal >= auxiliar->numeroSector) && (stConfig.iCantidadPistas - auxiliar->numeroSector < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = stConfig.iCantidadPistas - auxiliar->numeroSector;
				siguienteALeer = auxiliar->numeroSector;
				if(auxiliar->traceONoTrace == 1){
					*traceActivo = 1;
				}else{
					*traceActivo = 0;
				}
				if(auxiliar->sincro == 1){
					*sincroActivo = 1;
				}else{
					*sincroActivo = 0;
				}
			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = *punteroLectura;
			direccionSCAN = 1;
			cambioDeSentido = 1;
			siguienteALeer = auxiliar->numeroSector;
			if(auxiliar->traceONoTrace == 1){
				*traceActivo = 1;
			}else{
				*traceActivo = 0;
			}
			if(auxiliar->sincro == 1){
				*sincroActivo = 1;
			}else{
				*sincroActivo = 0;
			}
			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector < siguienteALeer){
					siguienteALeer = auxiliar->numeroSector;
					if(auxiliar->traceONoTrace == 1){
						*traceActivo = 1;
					}else{
						*traceActivo = 0;
					}
					if(auxiliar->sincro == 1){
						*sincroActivo = 1;
					}else{
						*sincroActivo = 0;
					}
				}
			auxiliar = auxiliar->siguiente;
			}
		}
	}

	if(traceTotal>0){
		if(*traceActivo){
			traceTotal--;
		}
		realizarTrace(siguienteALeer,cambioDeSentido);
	}else{
		if(siguienteALeer % stConfig.iSectoresPista == stConfig.iSectoresPista - 1)
			posicionCabezal = siguienteALeer - stConfig.iSectoresPista + 1;
		else {
			posicionCabezal = siguienteALeer;
			posicionCabezal++;
		}
	}

	*descriptor=(*punteroLectura)->descriptorAEnviar;
	buscarEliminarNodoLectura(&(*punteroLectura),siguienteALeer);

	return siguienteALeer;
}

int32_t algoritmoScanEscritura_ejecutar(struct estructuraEscribir **punteroEscritura, char *infoSector){

	int32_t siguienteAEscribir;
	int32_t diferenciaEntreSectores = 999999999;
	struct estructuraEscribir *auxiliar;
	struct estructuraEscribir *auxiliar2;

	auxiliar = *punteroEscritura;
	int32_t cambioDeSentido = 0;

	auxiliar2 = *punteroEscritura;

		while(auxiliar2){

			if(auxiliar2->numeroSector / stConfig.iSectoresPista == posicionCabezal / stConfig.iSectoresPista){
				siguienteAEscribir = auxiliar2->numeroSector;
				memcpy(infoSector,auxiliar2->infoSector,512);
				buscarEliminarNodoEscritura(&(*punteroEscritura),siguienteAEscribir);
				if(siguienteAEscribir % stConfig.iSectoresPista == stConfig.iSectoresPista - 1)
					posicionCabezal = siguienteAEscribir - stConfig.iSectoresPista + 1;
				else {
					posicionCabezal = siguienteAEscribir;
					posicionCabezal++;
				}

				return siguienteAEscribir;
			}
			pthread_mutex_lock(&mutexInfoSector2);
			auxiliar2=auxiliar2->siguiente;
			pthread_mutex_unlock(&mutexInfoSector2);
		}


	if(direccionSCAN)
	{
		while(auxiliar)
		{
			if((posicionCabezal <= auxiliar->numeroSector) && (auxiliar->numeroSector - stConfig.iCantidadPistas < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = auxiliar->numeroSector-stConfig.iCantidadPistas;
				siguienteAEscribir = auxiliar->numeroSector;
				memcpy(infoSector,auxiliar->infoSector,512);

			}
			pthread_mutex_lock(&mutexInfoSector2);
			auxiliar = auxiliar->siguiente;
			pthread_mutex_unlock(&mutexInfoSector2);
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = *punteroEscritura;
			direccionSCAN = 0;
			cambioDeSentido = 1;
			siguienteAEscribir = auxiliar->numeroSector;
			memcpy(infoSector,auxiliar->infoSector,512);
			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector > siguienteAEscribir){
					siguienteAEscribir = auxiliar->numeroSector;
					memcpy(infoSector,auxiliar->infoSector,512);
				}
				auxiliar = auxiliar->siguiente;
			}
		}
	}
	else
	{
		while(auxiliar)
		{
			if((posicionCabezal >= auxiliar->numeroSector) && (stConfig.iCantidadPistas - auxiliar->numeroSector < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = stConfig.iCantidadPistas - auxiliar->numeroSector;
				siguienteAEscribir = auxiliar->numeroSector;
				memcpy(infoSector,auxiliar->infoSector,512);
			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = *punteroEscritura;
			direccionSCAN = 1;
			cambioDeSentido = 1;
			siguienteAEscribir = auxiliar->numeroSector;
			memcpy(infoSector,auxiliar->infoSector,512);//TODO sem1
			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector < siguienteAEscribir){
					siguienteAEscribir = auxiliar->numeroSector;
					memcpy(infoSector,auxiliar->infoSector,512);
				}
				auxiliar = auxiliar->siguiente;
			}
		}

	}

	if(siguienteAEscribir % stConfig.iSectoresPista == stConfig.iSectoresPista - 1)
		posicionCabezal = siguienteAEscribir - stConfig.iSectoresPista + 1;
	else {
		posicionCabezal = siguienteAEscribir;
		posicionCabezal++;
	}
	buscarEliminarNodoEscritura(&(*punteroEscritura),siguienteAEscribir);

	return siguienteAEscribir;
}

void realizarTrace(int sectorABuscar, int cambioDeSentido){

	int pistasRecorridas;
	int sectoresRecorridos = 0;
	char recorridoRealizado[512];
	struct nipc_protocol punteroNIPCenviar;

	memset(recorridoRealizado,'\0',sizeof(recorridoRealizado));

	sprintf(recorridoRealizado,"Posicion actual: %d:%d\n", posicionCabezal/stConfig.iSectoresPista,posicionCabezal % stConfig.iSectoresPista);
	sprintf(recorridoRealizado + strlen(recorridoRealizado), "Sector solicitado: %d:%d (sector logico: %d)\n",sectorABuscar/stConfig.iSectoresPista,sectorABuscar % stConfig.iSectoresPista,sectorABuscar);

	if(sectorABuscar == posicionCabezal)
	{
		sprintf(recorridoRealizado + strlen(recorridoRealizado),"Sector recorrido: %d:%d\n",sectorABuscar/stConfig.iSectoresPista,sectorABuscar % stConfig.iSectoresPista);
		sprintf(recorridoRealizado + strlen(recorridoRealizado),"Tiempo consumido: %d ms\n",stConfig.iTiempoLectura);

		if((sectorABuscar % stConfig.iSectoresPista) == stConfig.iSectoresPista - 1)
			sprintf(recorridoRealizado + strlen(recorridoRealizado),"Proximo sector: %d:0\n\n",sectorABuscar/stConfig.iSectoresPista);
		else
			sprintf(recorridoRealizado + strlen(recorridoRealizado),"Proximo sector: %d:%d\n\n",sectorABuscar/stConfig.iSectoresPista,(sectorABuscar + 1) % stConfig.iSectoresPista );

		if(traceTotal){
			pthread_mutex_lock(&mutexEnviar);
			NIPC_enviar(descriptorSocketConsolaPPD,'U',512,recorridoRealizado,0); //no se porque la U, pero siginifica que continua el trace
			pthread_mutex_unlock(&mutexEnviar);
		}else{
			pthread_mutex_lock(&mutexEnviar);
			NIPC_enviar(descriptorSocketConsolaPPD,'F',512,recorridoRealizado,0); //Finalizo el trace
			pthread_mutex_unlock(&mutexEnviar);
		}

		if(posicionCabezal % stConfig.iSectoresPista == stConfig.iSectoresPista - 1)
			posicionCabezal = posicionCabezal - stConfig.iSectoresPista + 1;
		else
			posicionCabezal++;

	}
	else
	{
		sprintf(recorridoRealizado + strlen(recorridoRealizado),"Sectores Recorridos: ");
		if(posicionCabezal < sectorABuscar)
		{
			if(cambioDeSentido){
				if(posicionCabezal/stConfig.iSectoresPista != 0){
					sprintf(recorridoRealizado + strlen(recorridoRealizado),"0:0 (bajó hasta la pista inicial),");
				}
				pistasRecorridas = (posicionCabezal/stConfig.iSectoresPista) + (sectorABuscar/stConfig.iSectoresPista);
								//pistaActual + pistaDelSectorBuscado
			}else
				pistasRecorridas = (sectorABuscar/stConfig.iSectoresPista) - (posicionCabezal/stConfig.iSectoresPista);
								//pistaDelSectorBuscado - pistaActual
			if(direccionSCAN)
			{
				posicionCabezal = posicionCabezal + pistasRecorridas * stConfig.iSectoresPista;
			}
			else
			{
				posicionCabezal = posicionCabezal - pistasRecorridas * stConfig.iSectoresPista;
			}
		}
		else
		{
			if(cambioDeSentido){
				if(posicionCabezal/stConfig.iSectoresPista != stConfig.iSectoresPista-1){
					sprintf(recorridoRealizado + strlen(recorridoRealizado),"%d:%d (subió hasta la pista final), ",stConfig.iCantidadPistas-1, stConfig.iSectoresPista-1);
				}
				pistasRecorridas = (stConfig.iCantidadPistas - (posicionCabezal/stConfig.iSectoresPista)) + (stConfig.iCantidadPistas - (sectorABuscar/stConfig.iSectoresPista));
			}else{
				pistasRecorridas = (posicionCabezal/stConfig.iSectoresPista) - (sectorABuscar/stConfig.iSectoresPista);
			}
			posicionCabezal = posicionCabezal - ((posicionCabezal/stConfig.iSectoresPista) - (sectorABuscar/stConfig.iSectoresPista)) * stConfig.iSectoresPista;
		}

		sectoresRecorridos = 0;

		if(sectorABuscar % stConfig.iSectoresPista > posicionCabezal % stConfig.iSectoresPista)
		{

			while(sectorABuscar % stConfig.iSectoresPista != posicionCabezal % stConfig.iSectoresPista)
			{
				sprintf(recorridoRealizado + strlen(recorridoRealizado),"%d:%d, ", posicionCabezal/stConfig.iSectoresPista, posicionCabezal % stConfig.iSectoresPista);
				posicionCabezal++;
				sectoresRecorridos++;
				if(strlen(recorridoRealizado) > 400){
					pthread_mutex_lock(&mutexEnviar);
					NIPC_enviar(descriptorSocketConsolaPPD,'U',512,recorridoRealizado,0); //no se porque la U, pero siginifica que continua el trace
					pthread_mutex_unlock(&mutexEnviar);
					memset(recorridoRealizado,'\0',sizeof(recorridoRealizado));
				}
			}
		}
		else
		{
			while(posicionCabezal % stConfig.iSectoresPista != 0 && posicionCabezal != sectorABuscar)
			{
				sprintf(recorridoRealizado + strlen(recorridoRealizado),"%d:%d, ", posicionCabezal/stConfig.iSectoresPista, posicionCabezal % stConfig.iSectoresPista);
				posicionCabezal++;
				sectoresRecorridos++;
				if(strlen(recorridoRealizado) > 400){
					pthread_mutex_lock(&mutexEnviar);
					NIPC_enviar(descriptorSocketConsolaPPD,'U',512,recorridoRealizado,0); //no se porque la U, pero siginifica que continua el trace
					pthread_mutex_unlock(&mutexEnviar);
					memset(recorridoRealizado,'\0',sizeof(recorridoRealizado));
				}
			}
			if(posicionCabezal % stConfig.iSectoresPista == 0)
			{
				posicionCabezal = posicionCabezal - stConfig.iSectoresPista;
				while(posicionCabezal != sectorABuscar)
				{
					sprintf(recorridoRealizado + strlen(recorridoRealizado),"%d:%d, ", posicionCabezal/stConfig.iSectoresPista, posicionCabezal % stConfig.iSectoresPista);
					posicionCabezal++;
					sectoresRecorridos++;
					if(strlen(recorridoRealizado) > 400){
						pthread_mutex_lock(&mutexEnviar);
						NIPC_enviar(descriptorSocketConsolaPPD,'U',512,recorridoRealizado,0); //no se porque la U, pero siginifica que continua el trace
						pthread_mutex_unlock(&mutexEnviar);
						memset(recorridoRealizado,'\0',sizeof(recorridoRealizado));
					}
				}
			}
		}

		sprintf(recorridoRealizado + strlen(recorridoRealizado),"%d:%d\n",posicionCabezal/stConfig.iSectoresPista, posicionCabezal % stConfig.iSectoresPista);
		sprintf(recorridoRealizado + strlen(recorridoRealizado),"Tiempo consumido: %d ms\n", ((pistasRecorridas * stConfig.iTiempoSaltoPistas) + sectoresRecorridos * ((60000/stConfig.iRPM)/stConfig.iSectoresPista))+stConfig.iTiempoLectura);

		if(posicionCabezal % stConfig.iSectoresPista == stConfig.iSectoresPista - 1)
			posicionCabezal = posicionCabezal - stConfig.iSectoresPista + 1;
		else
			posicionCabezal++;

		sprintf(recorridoRealizado + strlen(recorridoRealizado),"Próximo sector: %d:%d\n\n", posicionCabezal/stConfig.iSectoresPista,posicionCabezal % stConfig.iSectoresPista);

		if(traceTotal){
			pthread_mutex_lock(&mutexEnviar);
			NIPC_enviar(descriptorSocketConsolaPPD,'U',512,recorridoRealizado,0); //no se porque la U, pero siginifica que continua el trace
			pthread_mutex_unlock(&mutexEnviar);
		}else{
			pthread_mutex_lock(&mutexEnviar);
			NIPC_enviar(descriptorSocketConsolaPPD,'F',512,recorridoRealizado,0); //Finalizo el trace
			pthread_mutex_unlock(&mutexEnviar);
		}
		//send(descriptorSocketConsolaPPD,recorridoRealizado,strlen(recorridoRealizado),0);
		//AQUI SE DEBERIA DE ENVIAR A LA PANTALLA EL TRACE REALIZADO QUE ESTA EN recorridoRealizado;
	}
}

void buscarEliminarNodoEscritura(estructuraEscribir **punteroFrenteAux,int valor){

	estructuraEscribir *auxiliar;
	estructuraEscribir *anterior;

	auxiliar = *punteroFrenteAux;

	while(auxiliar && (auxiliar->numeroSector != valor)){
		anterior = auxiliar;
		auxiliar = auxiliar->siguiente;
	}

	if(*punteroFrenteAux == auxiliar){
		if(*punteroFrenteAux == punteroFrenteEscribir){
			pthread_mutex_lock(&mutexInfoSector);
			punteroFrenteEscribir = punteroFrenteEscribir->siguiente;
			pthread_mutex_unlock(&mutexInfoSector);
				}
		*punteroFrenteAux = (*punteroFrenteAux)->siguiente;
	}
	else
		anterior->siguiente = auxiliar->siguiente;

	free(auxiliar);

	return;
}

void buscarEliminarNodoLectura(estructuraLeer **punteroFrenteAux, int valor){

	estructuraLeer *auxiliar;
	estructuraLeer *anterior;

	auxiliar = *punteroFrenteAux;

	while(auxiliar && (auxiliar->numeroSector != valor)){
		anterior = auxiliar;
		auxiliar = auxiliar->siguiente;
	}

	if(*punteroFrenteAux == auxiliar){
		if(*punteroFrenteAux == punteroFrenteLeer){
			pthread_mutex_lock(&mutexSincro);
			punteroFrenteLeer = punteroFrenteLeer->siguiente;
			pthread_mutex_unlock(&mutexSincro);
		}
		pthread_mutex_lock(&mutexSincro);
		*punteroFrenteAux = (*punteroFrenteAux)->siguiente;
		pthread_mutex_unlock(&mutexSincro);
	}else
		if(auxiliar==NULL)
			anterior->siguiente = auxiliar;
		else
			anterior->siguiente = auxiliar->siguiente;


	free(auxiliar);

	return;
}

/*
int algoritmoNScanLectura_ejecutar(struct estructuraLeer *punteroLectura, int *sincroActivo, int *traceActivo){

	int siguienteALeer;
	int diferenciaEntreSectores = 999999999;
	struct estructuraLeer *auxiliar;
	;
	struct estructuraLeer *punteroMentiraFin=NULL;
	struct estructuraLeer *auxiliar2;
	int cambioDeSentido = 0;

	auxiliar = punteroLectura;
	auxiliar2 = punteroLectura;

		while(auxiliar2){
			if(auxiliar2->numeroSector / stConfig.iSectoresPista == posicionCabezal / stConfig.iSectoresPista){
				siguienteALeer = auxiliar2->numeroSector;
				buscarEliminarNodoLectura(&(*punteroLectura), siguienteALeer);

				if(auxiliar->traceONoTrace == 1){
					traceActivo = 1;
				}else{
					traceActivo = 0;
				}

				if(auxiliar->sincro == 1){
					sincroActivo = 1;
				}else{
					sincroActivo = 0;
				}

				return siguienteALeer;
			}
		}

	if(direccionSCAN)
	{
		while(auxiliar)
		{
			if((posicionCabezal <= auxiliar->numeroSector) && (auxiliar->numeroSector - stConfig.iCantidadPistas < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = auxiliar->numeroSector-stConfig.iCantidadPistas;
				siguienteALeer = auxiliar->numeroSector;

				if(auxiliar->traceONoTrace == 1){
					traceActivo = 1;
				}else{
					traceActivo = 0;
				}
				if(auxiliar->sincro == 1){
					sincroActivo = 1;
				}else{
					sincroActivo = 0;
				}

			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = punteroLectura;
			direccionSCAN = 0;
			cambioDeSentido = 1;
			siguienteALeer = auxiliar->numeroSector;

			if(auxiliar->traceONoTrace == 1){
				traceActivo = 1;
			}else{
				traceActivo = 0;
			}
			if(auxiliar->sincro == 1){
				sincroActivo = 1;
			}else{
				sincroActivo = 0;
			}

			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector > siguienteALeer){
					siguienteALeer = auxiliar->numeroSector;
					if(auxiliar->traceONoTrace == 1){
						traceActivo = 1;
					}else{
						traceActivo = 0;
					}
					if(auxiliar->sincro == 1){
						sincroActivo = 1;
					}else{
						sincroActivo = 0;
					}
				}
				auxiliar = auxiliar->siguiente;
			}
		}
	}
	else
	{
		while(auxiliar)
		{
			if((posicionCabezal >= auxiliar->numeroSector) && (stConfig.iCantidadPistas - auxiliar->numeroSector < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = stConfig.iCantidadPistas - auxiliar->numeroSector;
				siguienteALeer = auxiliar->numeroSector;
				if(auxiliar->traceONoTrace == 1){
					traceActivo = 1;
				}else{
					traceActivo = 0;
				}
				if(auxiliar->sincro == 1){
					sincroActivo = 1;
				}else{
					sincroActivo = 0;
				}
			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = punteroLectura;
			direccionSCAN = 1;
			cambioDeSentido = 1;
			siguienteALeer = auxiliar->numeroSector;
			if(auxiliar->traceONoTrace == 1){
				traceActivo = 1;
			}else{
				traceActivo = 0;
			}
			if(auxiliar->sincro == 1){
				sincroActivo = 1;
			}else{
				sincroActivo = 0;
			}
			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector < siguienteALeer){
					siguienteALeer = auxiliar->numeroSector;
					if(auxiliar->traceONoTrace == 1){
						traceActivo = 1;
					}else{
						traceActivo = 0;
					}
					if(auxiliar->sincro == 1){
						sincroActivo = 1;
					}else{
						sincroActivo = 0;
					}
				}
			auxiliar = auxiliar->siguiente;
			}
		}
	}

	if(traceActivo){
			realizarTrace(siguienteALeer,cambioDeSentido);
	}


	buscarEliminarNodoLectura(&(*punteroLectura),siguienteALeer);

	return siguienteALeer;
}

int algoritmoNScanEscritura_ejecutar(struct estructuraEscribir *punteroEscritura){

	int siguienteAEscribir;
	int diferenciaEntreSectores = 999999999;
	struct estructuraEscribir *auxiliar;
	struct estructuraEscribir *punteroFinMentira=NULL;
	struct estructuraEscribir *auxiliar2;
	int cambioDeSentido = 0;

	auxiliar = punteroEscritura;
	auxiliar2 = punteroEscritura;

		while(auxiliar2){
			if(auxiliar2->numeroSector / stConfig.iSectoresPista == posicionCabezal / stConfig.iSectoresPista){
				siguienteAEscribir = auxiliar2->numeroSector;
				buscarEliminarNodoLectura(&(*punteroEscritura),siguienteAEscribir);
				return siguienteAEscribir;
			}
		}




	if(direccionSCAN)
	{
		while(auxiliar)
		{
			if((posicionCabezal <= auxiliar->numeroSector) && (auxiliar->numeroSector - stConfig.iCantidadPistas < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = auxiliar->numeroSector-stConfig.iCantidadPistas;
				siguienteAEscribir = auxiliar->numeroSector;
			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = punteroEscritura;
			direccionSCAN = 0;
			cambioDeSentido = 1;
			siguienteAEscribir = auxiliar->numeroSector;
			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector > siguienteAEscribir)
					siguienteAEscribir = auxiliar->numeroSector;
				auxiliar = auxiliar->siguiente;
			}
		}
	}
	else
	{
		while(auxiliar)
		{
			if((posicionCabezal >= auxiliar->numeroSector) && (stConfig.iCantidadPistas - auxiliar->numeroSector < diferenciaEntreSectores))
			{
				diferenciaEntreSectores = stConfig.iCantidadPistas - auxiliar->numeroSector;
				siguienteAEscribir = auxiliar->numeroSector;

			}
			auxiliar = auxiliar->siguiente;
		}

		if(diferenciaEntreSectores == 999999999)
		{
			auxiliar = punteroEscritura;
			direccionSCAN = 1;
			cambioDeSentido = 1;
			siguienteAEscribir = auxiliar->numeroSector;
			auxiliar = auxiliar->siguiente;

			while(auxiliar)
			{
				if(auxiliar->numeroSector < siguienteAEscribir)
					siguienteAEscribir = auxiliar->numeroSector;
				auxiliar = auxiliar->siguiente;
			}
		}

	}

	buscarEliminarNodoEscritura(&punteroEscritura,siguienteAEscribir);

	return siguienteAEscribir;
}*/

estructuraLeer *primeros10NodosLectura(estructuraLeer **punteroFrenteLeer){

	int32_t i;
	estructuraLeer *anterior = NULL;
	estructuraLeer *nodoPrimero = *punteroFrenteLeer;

	for(i = 1; i <= 10 && *punteroFrenteLeer != NULL; i++){
		anterior = *punteroFrenteLeer ;
		*punteroFrenteLeer  = (*punteroFrenteLeer)->siguiente;
	}
	if(anterior){
			anterior->siguiente = NULL;
		}

	return nodoPrimero;

}

estructuraEscribir *primeros500NodosEscritura(estructuraEscribir **punteroFrenteEscribir){

	int32_t i;
	estructuraEscribir *anterior = NULL;
	estructuraEscribir *nodoPrimero = *punteroFrenteEscribir;

	for(i = 1; i <= 500 && *punteroFrenteEscribir != NULL; i++){
		anterior = *punteroFrenteEscribir;
		*punteroFrenteEscribir  = (*punteroFrenteEscribir)->siguiente;
	}
	if(anterior){
		anterior->siguiente = NULL;
	}

	return nodoPrimero;

}











